<?php
/**
 * Zend Framework
 * LICENSE
 * This source file is subject to the new BSD license that is bundled
 * with this package in the file LICENSE.txt.
 * It is also available through the world-wide-web at this URL:
 * http://framework.zend.com/license/new-bsd
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@zend.com so we can send you a copy immediately.
 * @category Zend
 * @package Zend_Paginator
 * @copyright Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
 * @license http://framework.zend.com/license/new-bsd New BSD License
 * @version $Id: Paginator.php 24754 2012-05-05 02:30:56Z adamlundrigan $
 */
/**
 *
 * @see Zend_Loader_PluginLoader
 */
require_once 'Zend/Loader/PluginLoader.php';
/**
 *
 * @see Zend_Json
 */
require_once 'Zend/Json.php';

/**
 *
 * @category Zend
 * @package Zend_Paginator
 * @copyright Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
 * @license http://framework.zend.com/license/new-bsd New BSD License
 */
class Zend_Paginator implements Countable, IteratorAggregate {

    /**
     * Specifies that the factory should try to detect the proper adapter type first
     * @var string
     */
    const INTERNAL_ADAPTER = 'Zend_Paginator_Adapter_Internal';

    /**
     * The cache tag prefix used to namespace Paginator results in the cache
     */
    const CACHE_TAG_PREFIX = 'Zend_Paginator_';

    /**
     * Adapter plugin loader
     * @var Zend_Loader_PluginLoader
     */
    protected static $_adapterLoader = null;

    /**
     * Configuration file
     * @var Zend_Config
     */
    protected static $_config = null;

    /**
     * Default scrolling style
     * @var string
     */
    protected static $_defaultScrollingStyle = 'Sliding';

    /**
     * Default item count per page
     * @var int
     */
    protected static $_defaultItemCountPerPage = 10;

    /**
     * Default number of local pages (i.e., the number of discretes
     * page numbers that will be displayed, including the current
     * page number)
     * @var int
     */
    protected static $_defaultPageRange = 10;

    /**
     * Scrolling style plugin loader
     * @var Zend_Loader_PluginLoader
     */
    protected static $_scrollingStyleLoader = null;

    /**
     * Cache object
     * @var Zend_Cache_Core
     */
    protected static $_cache;

    /**
     * Enable or disable the cache by Zend_Paginator instance
     * @var bool
     */
    protected $_cacheEnabled = true;

    /**
     * Adapter
     * @var Zend_Paginator_Adapter_Interface
     */
    protected $_adapter = null;

    /**
     * Number of items in the current page
     * @var integer
     */
    protected $_currentItemCount = null;

    /**
     * Current page items
     * @var Traversable
     */
    protected $_currentItems = null;

    /**
     * Current page number (starting from 1)
     * @var integer
     */
    protected $_currentPageNumber = 1;

    /**
     * Result filter
     * @var Zend_Filter_Interface
     */
    protected $_filter = null;

    /**
     * Number of items per page
     * @var integer
     */
    protected $_itemCountPerPage = null;

    /**
     * Number of pages
     * @var integer
     */
    protected $_pageCount = null;

    /**
     * Number of local pages (i.e., the number of discrete page numbers
     * that will be displayed, including the current page number)
     * @var integer
     */
    protected $_pageRange = null;

    /**
     * Pages
     * @var array
     */
    protected $_pages = null;

    /**
     * View instance used for self rendering
     * @var Zend_View_Interface
     */
    protected $_view = null;

    /**
     * Adds an adapter prefix path to the plugin loader.
     * @param string $prefix
     * @param string $path
     */
    public static function addAdapterPrefixPath ($prefix, $path) {
        self::getAdapterLoader () -> addPrefixPath ($prefix, $path);
    }

    /**
     * Adds an array of adapter prefix paths to the plugin
     * loader.
     * <code>
     * $prefixPaths = array(
     * 'My_Paginator_Adapter' => 'My/Paginator/Adapter/',
     * 'Your_Paginator_Adapter' => 'Your/Paginator/Adapter/'
     * );
     * </code>
     * @param array $prefixPaths
     */
    public static function addAdapterPrefixPaths (array $prefixPaths) {
        if (isset ($prefixPaths['prefix']) && isset ($prefixPaths['path'])) {
            self::addAdapterPrefixPath ($prefixPaths['prefix'], $prefixPaths['path']);
        } else {
            foreach ($prefixPaths as $prefix => $path) {
                if (is_array ($path) && isset ($path['prefix']) && isset ($path['path'])) {
                    $prefix = $path['prefix'];
                    $path = $path['path'];
                }
                self::addAdapterPrefixPath ($prefix, $path);
            }
        }
    }

    /**
     * Adds a scrolling style prefix path to the plugin loader.
     * @param string $prefix
     * @param string $path
     */
    public static function addScrollingStylePrefixPath ($prefix, $path) {
        self::getScrollingStyleLoader () -> addPrefixPath ($prefix, $path);
    }

    /**
     * Adds an array of scrolling style prefix paths to the plugin
     * loader.
     * <code>
     * $prefixPaths = array(
     * 'My_Paginator_ScrollingStyle' => 'My/Paginator/ScrollingStyle/',
     * 'Your_Paginator_ScrollingStyle' => 'Your/Paginator/ScrollingStyle/'
     * );
     * </code>
     * @param array $prefixPaths
     */
    public static function addScrollingStylePrefixPaths (array $prefixPaths) {
        if (isset ($prefixPaths['prefix']) && isset ($prefixPaths['path'])) {
            self::addScrollingStylePrefixPath ($prefixPaths['prefix'], $prefixPaths['path']);
        } else {
            foreach ($prefixPaths as $prefix => $path) {
                if (is_array ($path) && isset ($path['prefix']) && isset ($path['path'])) {
                    $prefix = $path['prefix'];
                    $path = $path['path'];
                }
                self::addScrollingStylePrefixPath ($prefix, $path);
            }
        }
    }

    /**
     * Factory.
     * @param mixed $data
     * @param string $adapter
     * @param array $prefixPaths
     * @return Zend_Paginator
     */
    public static function factory ($data, $adapter = self::INTERNAL_ADAPTER, array $prefixPaths = null) {
        if ($data instanceof Zend_Paginator_AdapterAggregate) {
            return new self ($data -> getPaginatorAdapter ());
        } else {
            if ($adapter == self::INTERNAL_ADAPTER) {
                if (is_array ($data)) {
                    $adapter = 'Array';
                } else 
                    if ($data instanceof Zend_Db_Table_Select) {
                        $adapter = 'DbTableSelect';
                    } else 
                        if ($data instanceof Zend_Db_Select) {
                            $adapter = 'DbSelect';
                        } else 
                            if ($data instanceof Iterator) {
                                $adapter = 'Iterator';
                            } else 
                                if (is_integer ($data)) {
                                    $adapter = 'Null';
                                } else {
                                    $type = (is_object ($data)) ? get_class ($data) : gettype ($data);
                                    /**
                                     *
                                     * @see Zend_Paginator_Exception
                                     */
                                    require_once 'Zend/Paginator/Exception.php';
                                    throw new Zend_Paginator_Exception ('No adapter for type ' . $type);
                                }
            }
            $pluginLoader = self::getAdapterLoader ();
            if (null !== $prefixPaths) {
                foreach ($prefixPaths as $prefix => $path) {
                    $pluginLoader -> addPrefixPath ($prefix, $path);
                }
            }
            $adapterClassName = $pluginLoader -> load ($adapter);
            return new self (new $adapterClassName ($data));
        }
    }

    /**
     * Returns the adapter loader.
     * If it doesn't exist it's created.
     * @return Zend_Loader_PluginLoader
     */
    public static function getAdapterLoader () {
        if (self::$_adapterLoader === null) {
            self::$_adapterLoader = new Zend_Loader_PluginLoader (array('Zend_Paginator_Adapter' => 'Zend/Paginator/Adapter'));
        }
        return self::$_adapterLoader;
    }

    /**
     * Set a global config
     * @param Zend_Config $config
     */
    public static function setConfig (Zend_Config $config) {
        self::$_config = $config;
        $adapterPaths = $config -> get ('adapterpaths');
        if ($adapterPaths != null) {
            self::addAdapterPrefixPaths ($adapterPaths -> adapterpath -> toArray ());
        }
        $prefixPaths = $config -> get ('prefixpaths');
        if ($prefixPaths != null) {
            self::addScrollingStylePrefixPaths ($prefixPaths -> prefixpath -> toArray ());
        }
        $scrollingStyle = $config -> get ('scrollingstyle');
        if ($scrollingStyle != null) {
            self::setDefaultScrollingStyle ($scrollingStyle);
        }
    }

    /**
     * Returns the default scrolling style.
     * @return string
     */
    public static function getDefaultScrollingStyle () {
        return self::$_defaultScrollingStyle;
    }

    /**
     * Get the default item count per page
     * @return int
     */
    public static function getDefaultItemCountPerPage () {
        return self::$_defaultItemCountPerPage;
    }

    /**
     * Set the default item count per page
     * @param int $count
     */
    public static function setDefaultItemCountPerPage ($count) {
        self::$_defaultItemCountPerPage = (int) $count;
    }

    /**
     * Get the default page range
     * @return int
     */
    public static function getDefaultPageRange () {
        return self::$_defaultPageRange;
    }

    /**
     * Set the default page range
     * @param int $count
     */
    public static function setDefaultPageRange ($count) {
        self::$_defaultPageRange = (int) $count;
    }

    /**
     * Sets a cache object
     * @param Zend_Cache_Core $cache
     */
    public static function setCache (Zend_Cache_Core $cache) {
        self::$_cache = $cache;
    }

    /**
     * Sets the default scrolling style.
     * @param string $scrollingStyle
     */
    public static function setDefaultScrollingStyle ($scrollingStyle = 'Sliding') {
        self::$_defaultScrollingStyle = $scrollingStyle;
    }

    /**
     * Returns the scrolling style loader.
     * If it doesn't exist it's
     * created.
     * @return Zend_Loader_PluginLoader
     */
    public static function getScrollingStyleLoader () {
        if (self::$_scrollingStyleLoader === null) {
            self::$_scrollingStyleLoader = new Zend_Loader_PluginLoader (array('Zend_Paginator_ScrollingStyle' => 'Zend/Paginator/ScrollingStyle'));
        }
        return self::$_scrollingStyleLoader;
    }

    /**
     * Constructor.
     * @param Zend_Paginator_Adapter_Interface|Zend_Paginator_AdapterAggregate $adapter
     */
    public function __construct ($adapter) {
        if ($adapter instanceof Zend_Paginator_Adapter_Interface) {
            $this -> _adapter = $adapter;
        } else 
            if ($adapter instanceof Zend_Paginator_AdapterAggregate) {
                $this -> _adapter = $adapter -> getPaginatorAdapter ();
            } else {
                /**
                 *
                 * @see Zend_Paginator_Exception
                 */
                require_once 'Zend/Paginator/Exception.php';
                throw new Zend_Paginator_Exception ('Zend_Paginator only accepts instances of the type ' . 'Zend_Paginator_Adapter_Interface or Zend_Paginator_AdapterAggregate.');
            }
        $config = self::$_config;
        if ($config != null) {
            $setupMethods = array('ItemCountPerPage', 'PageRange');
            foreach ($setupMethods as $setupMethod) {
                $value = $config -> get (strtolower ($setupMethod));
                if ($value != null) {
                    $setupMethod = 'set' . $setupMethod;
                    $this -> $setupMethod ($value);
                }
            }
        }
    }

    /**
     * Serializes the object as a string.
     * Proxies to {@link render()}.
     * @return string
     */
    public function __toString () {
        try {
            $return = $this -> render ();
            return $return;
        } catch (Exception $e) {
            trigger_error ($e -> getMessage (), E_USER_WARNING);
        }
        return '';
    }

    /**
     * Enables/Disables the cache for this instance
     * @param bool $enable
     * @return Zend_Paginator
     */
    public function setCacheEnabled ($enable) {
        $this -> _cacheEnabled = (bool) $enable;
        return $this;
    }

    /**
     * Returns the number of pages.
     * @return integer
     */
    public function count () {
        if ( ! $this -> _pageCount) {
            $this -> _pageCount = $this -> _calculatePageCount ();
        }
        return $this -> _pageCount;
    }

    /**
     * Returns the total number of items available.
     * Uses cache if caching is enabled.
     * @return integer
     */
    public function getTotalItemCount () {
        if ( ! $this -> _cacheEnabled ()) {
            return count ($this -> getAdapter ());
        } else {
            $cacheId = md5 ($this -> _getCacheInternalId () . '_itemCount');
            $itemCount = self::$_cache -> load ($cacheId);
            if ($itemCount === false) {
                $itemCount = count ($this -> getAdapter ());
                self::$_cache -> save ($itemCount, $cacheId, array($this -> _getCacheInternalId ()));
            }
            return $itemCount;
        }
    }

    /**
     * Clear the page item cache.
     * @param int $pageNumber
     * @return Zend_Paginator
     */
    public function clearPageItemCache ($pageNumber = null) {
        if ( ! $this -> _cacheEnabled ()) {
            return $this;
        }
        if (null === $pageNumber) {
            foreach (self::$_cache -> getIdsMatchingTags (array($this -> _getCacheInternalId ())) as $id) {
                if (preg_match ('|' . self::CACHE_TAG_PREFIX . "(\d+)_.*|", $id, $page)) {
                    self::$_cache -> remove ($this -> _getCacheId ($page[1]));
                }
            }
        } else {
            $cleanId = $this -> _getCacheId ($pageNumber);
            self::$_cache -> remove ($cleanId);
        }
        return $this;
    }

    /**
     * Returns the absolute item number for the specified item.
     * @param integer $relativeItemNumber Relative item number
     * @param integer $pageNumber Page number
     * @return integer
     */
    public function getAbsoluteItemNumber ($relativeItemNumber, $pageNumber = null) {
        $relativeItemNumber = $this -> normalizeItemNumber ($relativeItemNumber);
        if ($pageNumber == null) {
            $pageNumber = $this -> getCurrentPageNumber ();
        }
        $pageNumber = $this -> normalizePageNumber ($pageNumber);
        return (($pageNumber - 1) * $this -> getItemCountPerPage ()) + $relativeItemNumber;
    }

    /**
     * Returns the adapter.
     * @return Zend_Paginator_Adapter_Interface
     */
    public function getAdapter () {
        return $this -> _adapter;
    }

    /**
     * Returns the number of items for the current page.
     * @return integer
     */
    public function getCurrentItemCount () {
        if ($this -> _currentItemCount === null) {
            $this -> _currentItemCount = $this -> getItemCount ($this -> getCurrentItems ());
        }
        return $this -> _currentItemCount;
    }

    /**
     * Returns the items for the current page.
     * @return Traversable
     */
    public function getCurrentItems () {
        if ($this -> _currentItems === null) {
            $this -> _currentItems = $this -> getItemsByPage ($this -> getCurrentPageNumber ());
        }
        return $this -> _currentItems;
    }

    /**
     * Returns the current page number.
     * @return integer
     */
    public function getCurrentPageNumber () {
        return $this -> normalizePageNumber ($this -> _currentPageNumber);
    }

    /**
     * Sets the current page number.
     * @param integer $pageNumber Page number
     * @return Zend_Paginator $this
     */
    public function setCurrentPageNumber ($pageNumber) {
        $this -> _currentPageNumber = (integer) $pageNumber;
        $this -> _currentItems = null;
        $this -> _currentItemCount = null;
        return $this;
    }

    /**
     * Get the filter
     * @return Zend_Filter_Interface
     */
    public function getFilter () {
        return $this -> _filter;
    }

    /**
     * Set a filter chain
     * @param Zend_Filter_Interface $filter
     * @return Zend_Paginator
     */
    public function setFilter (Zend_Filter_Interface $filter) {
        $this -> _filter = $filter;
        return $this;
    }

    /**
     * Returns an item from a page.
     * The current page is used if there's no
     * page sepcified.
     * @param integer $itemNumber Item number (1 to itemCountPerPage)
     * @param integer $pageNumber
     * @return mixed
     */
    public function getItem ($itemNumber, $pageNumber = null) {
        if ($pageNumber == null) {
            $pageNumber = $this -> getCurrentPageNumber ();
        } else 
            if ($pageNumber < 0) {
                $pageNumber = ($this -> count () + 1) + $pageNumber;
            }
        $page = $this -> getItemsByPage ($pageNumber);
        $itemCount = $this -> getItemCount ($page);
        if ($itemCount == 0) {
            /**
             *
             * @see Zend_Paginator_Exception
             */
            require_once 'Zend/Paginator/Exception.php';
            throw new Zend_Paginator_Exception ('Page ' . $pageNumber . ' does not exist');
        }
        if ($itemNumber < 0) {
            $itemNumber = ($itemCount + 1) + $itemNumber;
        }
        $itemNumber = $this -> normalizeItemNumber ($itemNumber);
        if ($itemNumber > $itemCount) {
            /**
             *
             * @see Zend_Paginator_Exception
             */
            require_once 'Zend/Paginator/Exception.php';
            throw new Zend_Paginator_Exception ('Page ' . $pageNumber . ' does not' . ' contain item number ' . $itemNumber);
        }
        return $page[$itemNumber - 1];
    }

    /**
     * Returns the number of items per page.
     * @return integer
     */
    public function getItemCountPerPage () {
        if (empty ($this -> _itemCountPerPage)) {
            $this -> _itemCountPerPage = self::getDefaultItemCountPerPage ();
        }
        return $this -> _itemCountPerPage;
    }

    /**
     * Sets the number of items per page.
     * @param integer $itemCountPerPage
     * @return Zend_Paginator $this
     */
    public function setItemCountPerPage ($itemCountPerPage = -1) {
        $this -> _itemCountPerPage = (integer) $itemCountPerPage;
        if ($this -> _itemCountPerPage < 1) {
            $this -> _itemCountPerPage = $this -> getTotalItemCount ();
        }
        $this -> _pageCount = $this -> _calculatePageCount ();
        $this -> _currentItems = null;
        $this -> _currentItemCount = null;
        return $this;
    }

    /**
     * Returns the number of items in a collection.
     * @param mixed $items Items
     * @return integer
     */
    public function getItemCount ($items) {
        $itemCount = 0;
        if (is_array ($items) || $items instanceof Countable) {
            $itemCount = count ($items);
        } else { // $items is something like LimitIterator
            $itemCount = iterator_count ($items);
        }
        return $itemCount;
    }

    /**
     * Returns the items for a given page.
     * @return Traversable
     */
    public function getItemsByPage ($pageNumber) {
        $pageNumber = $this -> normalizePageNumber ($pageNumber);
        if ($this -> _cacheEnabled ()) {
            $data = self::$_cache -> load ($this -> _getCacheId ($pageNumber));
            if ($data !== false) {
                return $data;
            }
        }
        $offset = ($pageNumber - 1) * $this -> getItemCountPerPage ();
        $items = $this -> _adapter -> getItems ($offset, $this -> getItemCountPerPage ());
        $filter = $this -> getFilter ();
        if ($filter !== null) {
            $items = $filter -> filter ($items);
        }
        if ( ! $items instanceof Traversable) {
            $items = new ArrayIterator ($items);
        }
        if ($this -> _cacheEnabled ()) {
            self::$_cache -> save ($items, $this -> _getCacheId ($pageNumber), array($this -> _getCacheInternalId ()));
        }
        return $items;
    }

    /**
     * Returns a foreach-compatible iterator.
     * @return Traversable
     */
    public function getIterator () {
        return $this -> getCurrentItems ();
    }

    /**
     * Returns the page range (see property declaration above).
     * @return integer
     */
    public function getPageRange () {
        if (null === $this -> _pageRange) {
            $this -> _pageRange = self::getDefaultPageRange ();
        }
        return $this -> _pageRange;
    }

    /**
     * Sets the page range (see property declaration above).
     * @param integer $pageRange
     * @return Zend_Paginator $this
     */
    public function setPageRange ($pageRange) {
        $this -> _pageRange = (integer) $pageRange;
        return $this;
    }

    /**
     * Returns the page collection.
     * @param string $scrollingStyle Scrolling style
     * @return array
     */
    public function getPages ($scrollingStyle = null) {
        if ($this -> _pages === null) {
            $this -> _pages = $this -> _createPages ($scrollingStyle);
        }
        return $this -> _pages;
    }

    /**
     * Returns a subset of pages within a given range.
     * @param integer $lowerBound Lower bound of the range
     * @param integer $upperBound Upper bound of the range
     * @return array
     */
    public function getPagesInRange ($lowerBound, $upperBound) {
        $lowerBound = $this -> normalizePageNumber ($lowerBound);
        $upperBound = $this -> normalizePageNumber ($upperBound);
        $pages = array();
        for ($pageNumber = $lowerBound; $pageNumber <= $upperBound; $pageNumber ++ ) {
            $pages[$pageNumber] = $pageNumber;
        }
        return $pages;
    }

    /**
     * Returns the page item cache.
     * @return array
     */
    public function getPageItemCache () {
        $data = array();
        if ($this -> _cacheEnabled ()) {
            foreach (self::$_cache -> getIdsMatchingTags (array($this -> _getCacheInternalId ())) as $id) {
                if (preg_match ('|' . self::CACHE_TAG_PREFIX . "(\d+)_.*|", $id, $page)) {
                    $data[$page[1]] = self::$_cache -> load ($this -> _getCacheId ($page[1]));
                }
            }
        }
        return $data;
    }

    /**
     * Retrieves the view instance.
     * If none registered, attempts to pull f
     * rom ViewRenderer.
     * @return Zend_View_Interface null
     */
    public function getView () {
        if ($this -> _view === null) {
            /**
             *
             * @see Zend_Controller_Action_HelperBroker
             */
            require_once 'Zend/Controller/Action/HelperBroker.php';
            $viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper ('viewRenderer');
            if ($viewRenderer -> view === null) {
                $viewRenderer -> initView ();
            }
            $this -> _view = $viewRenderer -> view;
        }
        return $this -> _view;
    }

    /**
     * Sets the view object.
     * @param Zend_View_Interface $view
     * @return Zend_Paginator
     */
    public function setView (Zend_View_Interface $view = null) {
        $this -> _view = $view;
        return $this;
    }

    /**
     * Brings the item number in range of the page.
     * @param integer $itemNumber
     * @return integer
     */
    public function normalizeItemNumber ($itemNumber) {
        $itemNumber = (integer) $itemNumber;
        if ($itemNumber < 1) {
            $itemNumber = 1;
        }
        if ($itemNumber > $this -> getItemCountPerPage ()) {
            $itemNumber = $this -> getItemCountPerPage ();
        }
        return $itemNumber;
    }

    /**
     * Brings the page number in range of the paginator.
     * @param integer $pageNumber
     * @return integer
     */
    public function normalizePageNumber ($pageNumber) {
        $pageNumber = (integer) $pageNumber;
        if ($pageNumber < 1) {
            $pageNumber = 1;
        }
        $pageCount = $this -> count ();
        if ($pageCount > 0 && $pageNumber > $pageCount) {
            $pageNumber = $pageCount;
        }
        return $pageNumber;
    }

    /**
     * Renders the paginator.
     * @param Zend_View_Interface $view
     * @return string
     */
    public function render (Zend_View_Interface $view = null) {
        if (null !== $view) {
            $this -> setView ($view);
        }
        $view = $this -> getView ();
        return $view -> paginationControl ($this);
    }

    /**
     * Returns the items of the current page as JSON.
     * @return string
     */
    public function toJson () {
        $currentItems = $this -> getCurrentItems ();
        if ($currentItems instanceof Zend_Db_Table_Rowset_Abstract) {
            return Zend_Json::encode ($currentItems -> toArray ());
        } else {
            return Zend_Json::encode ($currentItems);
        }
    }

    /**
     * Tells if there is an active cache object
     * and if the cache has not been desabled
     * @return bool
     */
    protected function _cacheEnabled () {
        return ((self::$_cache !== null) && $this -> _cacheEnabled);
    }

    /**
     * Makes an Id for the cache
     * Depends on the adapter object and the page number
     * Used to store item in cache from that Paginator instance
     * and that current page
     * @param int $page
     * @return string
     */
    protected function _getCacheId ($page = null) {
        if ($page === null) {
            $page = $this -> getCurrentPageNumber ();
        }
        return self::CACHE_TAG_PREFIX . $page . '_' . $this -> _getCacheInternalId ();
    }

    /**
     * Get the internal cache id
     * Depends on the adapter and the item count per page
     * Used to tag that unique Paginator instance in cache
     * @return string
     */
    protected function _getCacheInternalId () {
        $adapter = $this -> getAdapter ();
        if (method_exists ($adapter, 'getCacheIdentifier')) {
            return md5 (serialize (array($adapter -> getCacheIdentifier (), $this -> getItemCountPerPage ())));
        } else {
            return md5 (serialize (array($adapter, $this -> getItemCountPerPage ())));
        }
    }

    /**
     * Calculates the page count.
     * @return integer
     */
    protected function _calculatePageCount () {
        return (integer) ceil ($this -> getTotalItemCount () / $this -> getItemCountPerPage ());
    }

    /**
     * Creates the page collection.
     * @param string $scrollingStyle Scrolling style
     * @return stdClass
     */
    protected function _createPages ($scrollingStyle = null) {
        $pageCount = $this -> count ();
        $currentPageNumber = $this -> getCurrentPageNumber ();
        $pages = new stdClass ();
        $pages -> pageCount = $pageCount;
        $pages -> itemCountPerPage = $this -> getItemCountPerPage ();
        $pages -> first = 1;
        $pages -> current = $currentPageNumber;
        $pages -> last = $pageCount;
        // Previous and next
        if ($currentPageNumber - 1 > 0) {
            $pages -> previous = $currentPageNumber - 1;
        }
        if ($currentPageNumber + 1 <= $pageCount) {
            $pages -> next = $currentPageNumber + 1;
        }
        // Pages in range
        $scrollingStyle = $this -> _loadScrollingStyle ($scrollingStyle);
        $pages -> pagesInRange = $scrollingStyle -> getPages ($this);
        $pages -> firstPageInRange = min ($pages -> pagesInRange);
        $pages -> lastPageInRange = max ($pages -> pagesInRange);
        // Item numbers
        if ($this -> getCurrentItems () !== null) {
            $pages -> currentItemCount = $this -> getCurrentItemCount ();
            $pages -> itemCountPerPage = $this -> getItemCountPerPage ();
            $pages -> totalItemCount = $this -> getTotalItemCount ();
            $pages -> firstItemNumber = (($currentPageNumber - 1) * $this -> getItemCountPerPage ()) + 1;
            $pages -> lastItemNumber = $pages -> firstItemNumber + $pages -> currentItemCount - 1;
        }
        return $pages;
    }

    /**
     * Loads a scrolling style.
     * @param string $scrollingStyle
     * @return Zend_Paginator_ScrollingStyle_Interface
     */
    protected function _loadScrollingStyle ($scrollingStyle = null) {
        if ($scrollingStyle === null) {
            $scrollingStyle = self::$_defaultScrollingStyle;
        }
        switch (strtolower (gettype ($scrollingStyle))) {
            case 'object' :
                if ( ! $scrollingStyle instanceof Zend_Paginator_ScrollingStyle_Interface) {
                    /**
                     *
                     * @see Zend_View_Exception
                     */
                    require_once 'Zend/View/Exception.php';
                    throw new Zend_View_Exception ('Scrolling style must implement ' . 'Zend_Paginator_ScrollingStyle_Interface');
                }
                return $scrollingStyle;
            case 'string' :
                $className = self::getScrollingStyleLoader () -> load ($scrollingStyle);
                return new $className ();
            case 'null' :
            // Fall through to default case
            default :
                /**
                 *
                 * @see Zend_View_Exception
                 */
                require_once 'Zend/View/Exception.php';
                throw new Zend_View_Exception ('Scrolling style must be a class ' . 'name or object implementing Zend_Paginator_ScrollingStyle_Interface');
        }
    }

}
